import { _decorator, Button, Color, color, Component, instantiate, Label, Node, Prefab, Sprite, SpriteFrame, Toggle } from 'cc';

import { Core } from '../Core/Core';
import { ResourceManager } from '../Core/ResourceManager';
import { EEvent, EPath, ESubView, EView } from '../Config/Enum';
import { EItemQuality, EItemType, IItem, ItemQualityColors } from '../Item/Item';
import { BagItem } from '../Item/BagItem';
import { PrefabPath } from '../Config/ResourceConfig';
import { Equipment, IEquipment } from '../Item/Equipment';
import { Util } from '../Util';
import { MAX_QUIPMENT_LEVEL } from '../Config/Config';


const { ccclass, property } = _decorator;

@ccclass('ArsenalView')
export class ArsenalView extends Component {
        // 添加定时器引用
    private refreshTimer: number = 0;

    ndBG: Node = null!; // 背景节点
    ndShaixuan: Node = null!; // 筛选节点

    ndBag: Node = null!; // 背包节点
    ndShop: Node = null!; // 商店节点
    ndForge: Node = null!; // 锻造节点
    ndbtnBag: Node = null!; // 背包按钮
    ndbtnShop: Node = null!; // 商店按钮
    ndbtnForge: Node = null!; // 锻造按钮
    ndButtons: Node = null!; // 按钮节点
    //ndShopItemDetail:Node
    btnBag: Button = null!; // 背包按钮组件
    btnShop: Button = null!; // 商店按钮组件
    btnForge: Button = null!; // 锻造按钮组件

    shopItems: IItem[] = []; // 商店物品列表

    lbNumOfItems: Label = null!; // 背包物品数量标签
    lbRefreshTime: Label = null!; // 刷新时间标签

    // Forge
    ndAffixParent: Node;
    ndForgeBagItem: Node;
    equipment_forge: Equipment;
    private forgeItems: IEquipment[] = []; // 存储当前类型的装备物品列表
    lbAPDP_forge: Label;
    value_forge: number;

    

    protected onLoad(): void {
        //this.ndBG = this.node.getChildByName("BG");
        this.ndButtons = this.node.getChildByName("Buttons");
        this.ndBag = this.node.getChildByName("Bag");
        this.ndShop = this.node.getChildByName("Shop");
        this.ndForge = this.node.getChildByName("Forge");
        this.ndbtnBag = this.ndButtons.getChildByName("Button_Bag");
        this.ndbtnShop = this.ndButtons.getChildByName("Button_Shop");
        this.ndbtnForge = this.ndButtons.getChildByName("Button_Forge");
        //this.ndShopItemDetail = this.node.parent.getChildByName("ShopItemDetail");

        
        this.btnBag = this.ndbtnBag.getComponent(Button);
        this.btnShop = this.ndbtnShop.getComponent(Button);
        this.btnForge = this.ndbtnForge.getComponent(Button);
        // Bag
        this.ndShaixuan = this.ndBag.getChildByName("Shaixuan");
        this.ndShaixuan.active = false;
        // Shop
        this.lbNumOfItems = this.ndBag.getChildByName("ScrollView").getChildByName("NumOfItems").getComponent(Label);
        this.lbRefreshTime = this.ndShop.getChildByName("ScrollView").getChildByName("RefreshTime").getComponent(Label);

        //Forge
        this.ndAffixParent = this.ndForge.getChildByName("Board").getChildByName("Affixes");
        this.ndForgeBagItem = this.ndForge.getChildByName("Board").getChildByName("Icon").getChildByName("BagItem");
        this.equipment_forge = null!;
        this.lbAPDP_forge = this.ndForge.getChildByName("Board").getChildByName("APDP").getComponent(Label);
        this.value_forge = null!;

        


    }

    protected onEnable(): void {
        this.ndBag.active = true;
        this.ndShop.active = false;
        this.ndForge.active = false;
        Core.Instance.event.on(EEvent.ShopBuy, this.onButtonBuy, this);
        Core.Instance.event.on(EEvent.OpenForgeView, this.onButtonOpenForge, this);
        Core.Instance.event.on(EEvent.ItemSold, this.refreshBag, this);



        this.onButtonOpenBag(); // 初始化背包

        Core.Instance.currentView = EView.ArsenalView;

                // 启动定时器
        //this.startRefreshTimer();
        this.updateRefreshTimeDisplay();

    }

    protected onDisable(): void {
        Core.Instance.event.off(EEvent.ShopBuy, this.onButtonBuy, this);
        Core.Instance.event.off(EEvent.OpenForgeView, this.onButtonOpenForge, this);
        Core.Instance.event.off(EEvent.ItemSold, this.refreshBag, this);
        Core.Instance.currentView = null;
        Core.Instance.currentSubView = null
                
        // 停止定时器
        //this.stopRefreshTimer();
    }

        // 启动刷新时间定时器
    private startRefreshTimer(): void {
        this.stopRefreshTimer(); // 先停止之前的定时器
        
        // 每秒更新一次时间显示
        this.refreshTimer = setInterval(() => {
            this.updateRefreshTimeDisplay();
        }, 1000);
        
        // 立即更新一次显示
        this.updateRefreshTimeDisplay();
    }

    

        // 停止刷新时间定时器
    private stopRefreshTimer(): void {
        if (this.refreshTimer) {
            clearInterval(this.refreshTimer);
            this.refreshTimer = 0;
        }
    }

    // 更新刷新时间显示
    private updateRefreshTimeDisplay(): void {
        if (!this.lbRefreshTime) return;
        
        const remainingTime = Core.Instance.getShopRefreshRemainingTime();
        
        if (remainingTime <= 0) {
            this.lbRefreshTime.string = "";
        } else {
            // 计算分钟和秒数
            const minutes = Math.floor(remainingTime / 60);
            const seconds = remainingTime % 60;
            
            // 格式化为"X分X秒"
            this.lbRefreshTime.string = `还需${minutes}分${seconds}秒刷新`;
        }
    }

    /**
     * 异步分帧创建节点
     * @param totalCount 总共需要的数量
     * @param callback 完成后的回调
     */
    private asyncEnsureShopNodes(totalCount: number, callback: Function) {
        const contentNode = this.ndShop.getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        const prefab = ResourceManager.Instance.getResourceCache().get(PrefabPath.BagItem) as Prefab;
        
        let currentCount = contentNode.children.length;
        if (currentCount >= totalCount) {
            callback();
            return;
        }

        // 每帧创建的数量，数字越小越流畅，但加载总时间越长
        const itemsPerFrame = 2; 
        
        // 定义一个调度器回调
        const scheduler = () => {
            // 这一帧创建 itemsPerFrame 个
            for (let i = 0; i < itemsPerFrame; i++) {
                if (contentNode.children.length >= totalCount) {
                    this.unschedule(scheduler); // 数量够了，停止调度
                    callback(); // 执行后续逻辑（生成数据、刷新显示）
                    return;
                }
                
                const bagItemNode = instantiate(prefab);
                bagItemNode.name = `ShopItem_${contentNode.children.length}`;
                contentNode.addChild(bagItemNode);
            }
        };

        // 开始调度，间隔0秒（即每一帧执行一次）
        this.schedule(scheduler, 0);
    }



    // 创建背包格子
    createBagItem(ndName:ESubView=ESubView.Bag) {
        console.log("创建背包格子节点");
        // 获取内容容器节点
        const contentNode = this.node.getChildByName(ndName).getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        
        // 清除现有节点（可选，根据需求决定）
        contentNode.removeAllChildren();
        
        // 获取BagItem预制体
        const prefab = ResourceManager.Instance.getResourceCache().get(PrefabPath.BagItem) as Prefab;
        console.log("BagItem 预制体:", prefab);
        
        // 创建指定数量的背包格子
        for (let i = 0; i < Core.Instance.maxBag; i++) {
            const bagItemNode = instantiate(prefab);
            bagItemNode.name = `BagItem${i + 1}`; // 设置名称：BagItem1, BagItem2...
            contentNode.addChild(bagItemNode);
        }
    }

    // 创建空的商店格子
    createBlankShopItem() {
        console.log("创建商店格子节点");
        // 获取内容容器节点
        const contentNode = this.node.getChildByName("Shop").getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        
        // 清除现有节点（可选，根据需求决定）
        contentNode.removeAllChildren();
        
        // 获取ShopItem预制体
        const prefab = ResourceManager.Instance.getResourceCache().get(PrefabPath.BagItem) as Prefab;
        
        // 创建指定数量的背包格子
        for (let i = 0; i < Core.Instance.maxBag; i++) {
            const bagItemNode = instantiate(prefab);
            bagItemNode.name = `ShopItem${i + 1}`; // 设置名称 
            contentNode.addChild(bagItemNode);
        }
    }

    refreshShopBag() {
        console.log("刷新商店物品列表:", Core.Instance.shopBag);
        const contentNode = this.ndShop.getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        this.createShopItem();
        // 遍历所有商店格子并初始化
        for (let i = 0; i < contentNode.children.length; i++) {
            const bagItemNode = contentNode.children[i];
            const shopItemComp = bagItemNode.getComponent(BagItem);
            if (i < Core.Instance.shopBag.getItems().length) {
                console.log("初始化商店物品:", Core.Instance.shopBag.getItems()[i]);
                shopItemComp.init(Core.Instance.shopBag.getItems()[i]);
                bagItemNode.active = true;
            }
            else {
                // 保持空格子显示（但无物品）还需
                //bagItemComp.init(null); // 初始化为空状态
            }
        }
    }

    

    refreshBag() {
        console.log("刷新背包物品列表:", Core.Instance.bag);
        const contentNode = this.ndBag.getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        this.createBagItem();
        const bagItems = Core.Instance.bag.getItems();
        // 遍历所有背包格子并初始化
        for (let i = 0; i < contentNode.children.length; i++) {
            const bagItemNode = contentNode.children[i];
            const bagItemComp = bagItemNode.getComponent(BagItem);
            if (i < bagItems.length) {
                // 初始化有物品的格子
                bagItemComp.init(bagItems[i]);
                bagItemNode.active = true;
            } else {
                // 保持空格子显示（但无物品）
                //bagItemComp.init(null); // 初始化为空状态
            }
        }
        this.lbNumOfItems.string = `${Core.Instance.bag.getItems().length}/${Core.Instance.maxBag}`;
    }

    refreshMainHeader(){

    }

    // 打开仓库
    onButtonOpenBag() {
        console.log("初始化背包");
        Core.Instance.currentSubView = ESubView.Bag;


        Core.Instance.lastOpenArsenal = "Bag"
        // 显示背包界面，隐藏其他两个界面
        this.ndBag.active = true;
        this.ndShop.active = false;
        this.ndForge.active = false;
        this.ndbtnBag.getComponent(Sprite).color = Color.WHITE;
        this.ndbtnShop.getComponent(Sprite).color = Color.GRAY
        this.ndbtnForge.getComponent(Sprite).color =  Color.GRAY

        // 显示数量
        this.lbNumOfItems.string = `${Core.Instance.bag.getItems().length}/${Core.Instance.maxBag}`;
        this.createBagItem(); // 创建所有背包格子
        const bagItems = Core.Instance.bag.getItems();

        const contentNode = this.ndBag.getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        
        // 遍历所有背包格子并初始化
        for (let i = 0; i < contentNode.children.length; i++) {
            const bagItemNode = contentNode.children[i];
            const bagItemComp = bagItemNode.getComponent(BagItem);
            
            if (i < bagItems.length) {
                // 初始化有物品的格子
                bagItemComp.init(bagItems[i]);
                bagItemNode.active = true;
            } else {
                // 保持空格子显示（但无物品）
                //bagItemComp.init(null); // 初始化为空状态
            }
        }
    }


    /////////////////////////////////  / 军需官     //////////////////////////////////////////////////////////////////

    onButtonOpenShop(){
        console.log("打开商店界面");


        // 更新显示
        this.updateRefreshTimeDisplay();


        Core.Instance.lastOpenArsenal = "Shop"
        Core.Instance.currentSubView = ESubView.Shop;
        // 显示商店界面，隐藏其他两个界面
        this.ndBag.active = false;
        this.ndShop.active = true;
        this.ndForge.active = false;
        this.ndbtnShop.getComponent(Sprite).color = Color.WHITE;
        this.ndbtnBag.getComponent(Sprite).color = Color.GRAY
        this.ndbtnForge.getComponent(Sprite).color = Color.GRAY

                // 使用分帧加载，防止界面卡死
        // 显示一个 Loading 遮罩比较好（可选）
        this.asyncEnsureShopNodes(20, () => {
            this.createShopItem(); // 节点都准备好了，现在去填充数据
        });

    }
    
        /**
     * 优化1：节点复用
     * 确保商店有足够的格子节点，而不是每次都销毁重建
     */
    ensureShopItemNodes(targetCount: number) {
        const contentNode = this.ndShop.getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        const currentCount = contentNode.children.length;

        // 1. 如果节点不够，补充实例化
        if (currentCount < targetCount) {
            console.log(`节点复用：当前${currentCount}个，需补充${targetCount - currentCount}个`);
            // 获取ShopItem预制体 (注意：这里建议缓存预制体引用，不要每次都去资源管理器查)
            const prefab = ResourceManager.Instance.getResourceCache().get(PrefabPath.BagItem) as Prefab;
            
            // 分帧处理：如果缺口很大（比如第一次打开缺20个），建议分帧，否则还是会微卡
            // 这里先用简单的同步补齐，如果依然卡顿，请看下方的分帧方案
            for (let i = currentCount; i < targetCount; i++) {
                const bagItemNode = instantiate(prefab);
                bagItemNode.name = `ShopItem${i + 1}`;
                contentNode.addChild(bagItemNode);
            }
        }

        // 2. 无论够不够，先把所有节点设为 active = true (因为刷新时可能有些被隐藏了)
        // 如果节点多了，多余的在 updateShopItemsData 里隐藏
        for(let i=0; i< contentNode.children.length; i++) {
            if(i < targetCount) {
                contentNode.children[i].active = true;
            } else {
                contentNode.children[i].active = false;
            }
        }
    }


    /**
     * 创建商店物品
     * 该方法用于初始化商店界面，生成随机物品并填充到商店格子中
     */
    /**
     * 优化2：分离数据生成与视图更新
     */
    createShopItem() {
        const TARGET_COUNT = 20; // 目标数量

        // 1. 确保节点存在 (只在第一次打开时会有实例化开销，后续都是0开销)
        this.ensureShopItemNodes(TARGET_COUNT);
        
        const contentNode = this.ndShop.getChildByName("ScrollView").getChildByName("view").getChildByName("content");

        // 2. 数据层：生成物品 (如果这里卡，说明 generateItem 逻辑太重)
        if (Core.Instance.shopBag.getItems().length == 0) {
            for (let i = 0; i < TARGET_COUNT; i++) {
                let item = Core.Instance.generateItem(EItemType.Equipment, Math.floor(Math.random() * 5) + 1);
                Core.Instance.shopBag.addItem(item);
            }
        }

        console.log("商店物品列表和数量:", Core.Instance.shopBag, Core.Instance.shopBag.getItems().length);

        // 3. 视图层：更新数据 (只调用 init，不创建销毁)
        const items = Core.Instance.shopBag.getItems();
        
        for (let i = 0; i < contentNode.children.length; i++) {
            const bagItemNode = contentNode.children[i];
            
            // 只有在这个节点是 active 的情况下才去获取组件更新，节省性能
            if (!bagItemNode.active) continue;

            const bi = bagItemNode.getComponent(BagItem);
            
            if (i < items.length) {
                // 有数据，更新视图
                // console.log("更新商店格子:", i); // 调试日志太多也会卡，建议注释
                bi.init(items[i]); 
            } else {
                // 有节点但没数据（比如只有15个商品但有20个格子），隐藏节点或显示为空
                bagItemNode.active = false; 
            }
        }
    }

    onButtonRefreshShop() {
        console.log("刷新商店界面");
        // 刷新商店界面，重新生成随机物品

        const remainingTime = Core.Instance.getShopRefreshRemainingTime();
        if (remainingTime > 0) {
            // 计算分钟和秒数
            const minutes = Math.floor(remainingTime / 60);
            const seconds = remainingTime % 60;
            
            Core.Instance.showTips(`刷新冷却中，还需${minutes}分${seconds}秒`);
            return;
        }

        // 1. 清空背包数据 (这步很快)
        Core.Instance.shopBag.removeAllItems(); 
        
        // 2. 重新生成并刷新视图 (此时 ensureShopItemNodes 不会执行任何实例化，纯粹是数据刷新)
        this.createShopItem();
        
        Core.Instance.lastRefreshShopTime = Date.now();
        this.updateRefreshTimeDisplay();
    }





    /////////////////////////////////////////////// 仓库 ///////////////////////////////////////////////


    onButtonGetAllItems() {
        console.log("获取所有物品列表");
        const allItems = Core.Instance.bag.getItems();
        console.log("获取到的物品数量:", allItems.length);
        const contentNode = this.node.getChildByName("Bag").getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        this.createBagItem();
        // 遍历所有物品
        for (let i = 0; i < allItems.length; i++) {
            const item = allItems[i];
            console.log("当前物品:", item);
            const bagItemNode = contentNode.children[i];
            //const bagItemNode = instantiate(ResourceManager.Instance.getRes<Node>(EPath.Prefab.BagItem));
            const bagItemComp = bagItemNode.getComponent(BagItem);
            bagItemComp.init(item);
            contentNode.addChild(bagItemNode);
        }
    }

    onButtonGetEquipmentItems() {
        console.log("获取装备物品列表");

        const equipmentItems = Core.Instance.bag.getEquipmentItems();
        console.log("获取到的装备物品数量:", equipmentItems.length);
        const contentNode = this.node.getChildByName("Bag").getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        this.createBagItem(); // 重新创建所有背包格子
        // 遍历所有装备物品
        for (let i = 0; i < equipmentItems.length; i++) {
            const item = equipmentItems[i];
            console.log("当前装备物品:", item);
            const bagItemNode = contentNode.children[i];
            //const bagItemNode = instantiate(ResourceManager.Instance.getRes<Node>(EPath.Prefab.BagItem));
            const bagItemComp = bagItemNode.getComponent(BagItem);
            bagItemComp.init(item);
            contentNode.addChild(bagItemNode);
        }
    }

    onButtonGetOtherItems() {
        console.log("获取其他物品列表");

        const otherItems = Core.Instance.bag.getOtherItems();
        console.log("获取到的其他物品数量:", otherItems.length);
        const contentNode = this.node.getChildByName("Bag").getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        this.createBagItem(); // 重新创建所有背包格子
        // 遍历所有装备物品
        for (let i = 0; i < otherItems.length; i++) {
            const item = otherItems[i];
            console.log("当前其他物品:", item);
            const bagItemNode = contentNode.children[i];
            //const bagItemNode = instantiate(ResourceManager.Instance.getRes<Node>(EPath.Prefab.BagItem));
            const bagItemComp = bagItemNode.getComponent(BagItem);
            bagItemComp.init(item);
            contentNode.addChild(bagItemNode);
        }
    }

    onButtonCloseThisWindow(){
        console.log("关闭窗口")
        this.node.active = false
    }

// 打开筛选界面
    onButtonOpenShaixuan() {
        console.log("打开筛选界面");
        this.ndShaixuan.active = true;

        const ndBoard = this.ndShaixuan.getChildByName("Board");
        if (!ndBoard) return;

        // 节点名 -> 品质映射
        const qualityMap: { [key: string]: EItemQuality } = {
            "Common": EItemQuality.Common,
            "Uncommon": EItemQuality.Uncommon,
            "Rare": EItemQuality.Rare,
            "Epic": EItemQuality.Epic,
            "Legendary": EItemQuality.Legendary,
            "Artifact": EItemQuality.Artifact
        };

        for (const nodeName in qualityMap) {
            const quality = qualityMap[nodeName];
            const ndToggle = ndBoard.getChildByName(nodeName);
            
            if (ndToggle) {
                const toggleComp = ndToggle.getComponent(Toggle);
                if (toggleComp) {
                    // 1. 先临时移除事件监听，防止 setValue 触发回调导致逻辑死循环或重复计算
                    // 注意：这里假设你在编辑器里绑定的事件名叫 onButtonCheckEquipmentRarity
                    // 如果没法移除（编辑器绑定的很难移除），就使用上面的新版 onButtonCheckEquipmentRarity 逻辑
                    
                    // 使用新版逻辑：直接设置 isChecked
                    const shouldCheck = Core.Instance.checkEquipmentRarity.has(quality);
                    
                    // 只有当状态不一致时才赋值，减少不必要的事件触发
                    if (toggleComp.isChecked !== shouldCheck) {
                        toggleComp.isChecked = shouldCheck;
                    }
                }
            }
        }
    }



/**
     * 筛选Toggle回调
     * 注意：请确保编辑器里 Toggle 的 checkEvents 绑定的是这个函数
     * 第一个参数是 Toggle 组件本身
     * 第二个参数是 CustomEventData (需要在编辑器填入 '1', '2', '3' 等对应枚举值)
     */
    onButtonCheckEquipmentRarity(toggle: Toggle, customEventData: string) {
        // 将字符串转为数字
        const quality = parseInt(customEventData) as EItemQuality;
        
        if (isNaN(quality)) {
            console.error("筛选参数错误: customEventData 不是数字");
            return;
        }

        // === 核心修改 ===
        // 不再判断 Set 里有没有，而是判断 UI 现在的状态是什么
        if (toggle.isChecked) {
            // UI 是勾选状态 -> 数据层必须有这个值
            Core.Instance.checkEquipmentRarity.add(quality);
        } else {
            // UI 是未勾选状态 -> 数据层必须移除这个值
            Core.Instance.checkEquipmentRarity.delete(quality);
        }

        console.log(`筛选变更: ${quality}, 当前状态: ${toggle.isChecked}, 集合:`, Core.Instance.checkEquipmentRarity);
        Core.Instance.save();
        
        // 建议：点击后立即刷新背包显示
        this.refreshBag();
    }


    onButtonSellBatch() {
        console.log("尝试批量出售");

        // 1. 获取当前勾选的筛选品质
        const qualities = Core.Instance.checkEquipmentRarity;

        // 校验：是否选择了品质
        if (!qualities || qualities.size === 0) {
            Core.Instance.showTips("请先在筛选栏勾选要出售的装备品质！");
            return;
        }

        // 2. 从背包管理器获取符合条件的装备
        // 注意：这里获取的是引用数组，后续删除操作是安全的
        const itemsToSell = Core.Instance.bag.getEquipmentsByQualities(qualities);

        // 3. 二次筛选：安全检查
        // 过滤掉已装备的物品(isEquipped) 或者 锁定的物品(如果有锁定逻辑)
        const validItems = itemsToSell.filter(item => {
            if (item.isEquipped) return false; // 穿在身上的不能卖
            // if (item.isLocked) return false; // 如果以后有锁定功能，在这里加
            return true;
        });

        // 校验：是否有可卖物品
        if (validItems.length === 0) {
            Core.Instance.showTips("当前筛选条件下没有可出售的物品！");
            return;
        }

        // 4. 计算总价并执行删除
        let totalGain = 0;
        let soldCount = 0;

        // 建议：实际项目中这里应该弹出一个确认框 (Confirm Dialog)
        // 显示："是否确认出售 X 件装备，获得 Y 铜钱？"
        // 目前先直接执行出售逻辑：

        for (const item of validItems) {
            const price = item.price || 0;
            
            // 调用 BagManager 移除物品
            const success = Core.Instance.bag.removeItem(item);
            
            if (success) {
                totalGain += price;
                soldCount++;
            }
        }

        // 5. 结算处理
        if (soldCount > 0) {
            // 增加铜钱
            Core.Instance.gold += totalGain;
            
            // 提示玩家
            Core.Instance.showTips(`成功出售 ${soldCount} 件装备，获得 ${totalGain} 铜钱！`);

            // 6. 数据保存与UI刷新
            Core.Instance.save();
            
            // 发送资源变更事件（更新铜钱UI）
            Core.Instance.event.emit(EEvent.ResourceChanged);
            
            // 刷新背包格子显示
            this.refreshBag();
            
            console.log(`批量出售完成。数量:${soldCount}, 总价:${totalGain}`);
        } else {
            Core.Instance.showTips("出售失败，请检查物品状态");
        }
    }

    /////////////////////////////////////////////// 商店 ///////////////////////////////////////////////

    onButtonBuy(): void {
        // 购买逻辑
        console.log("购买物品");

        // 检查余额,如果余额不足,提示
        const currentItem = Core.Instance.currentItem;
        if (!currentItem) return;

        const playerData = Core.Instance.players.get(Core.Instance.currentPlayer);
        if (!playerData) return;

        if (Core.Instance.gold < (currentItem as any).price) {
            Core.Instance.showTips("铜钱不足，无法购买！");
            return;
        }
        // 扣除铜钱
        Core.Instance.gold -= (currentItem as any).price;
        // 添加物品到玩家背包
        Core.Instance.bag.addItem(currentItem);
        // 商店移除该物品
        Core.Instance.shopBag.removeItem(currentItem, 1);
        // 提示购买成功
        Core.Instance.showTips(`成功购买 ${currentItem.name} !`);
        console.log("购买物品成功Core.Instance.bag:", Core.Instance.bag);

        Core.Instance.save();
        // 关闭详情界面
        //this.node.active = false;
        //this.ndShopItemDetail.active = false
        // 更新商店物品显示
        this.refreshShopBag();
        // 更新背包物品显示
        this.refreshBag();

        Core.Instance.event.emit(EEvent.ResourceChanged)
        
        




    }



    //////////////////////////// 锻造 ////////////////////////////
    onButtonOpenForge(){
        console.log("初始化背包");
        Core.Instance.currentSubView = ESubView.Forge;


        Core.Instance.lastOpenArsenal = "Forge"
        // 显示背包界面，隐藏其他两个界面
        this.ndBag.active = false;
        this.ndShop.active = false;
        this.ndForge.active = true;
        this.ndbtnBag.getComponent(Sprite).color =  Color.GRAY
        this.ndbtnShop.getComponent(Sprite).color =  Color.GRAY
        this.ndbtnForge.getComponent(Sprite).color = Color.WHITE;

        this.initBagItem(ESubView.Forge);

        console.log("当前锻造装备this.equipment_forge:", this.equipment_forge);
        console.log("当前锻造装备Core.Instance.currentItem:", Core.Instance.currentItem);

        // 把当前装备加载到锻造界面
        // if(Core.Instance.currentItem){
        //     let index = Core.Instance.bag.getItems().indexOf(Core.Instance.currentItem)
        //     console.log("当前锻造装备index:", index);
        //     if(index!=-1){
        //         this.onButtonLoadItemToForge(index+1);
        //     }
        // }

        this.onButtonLoadItemToForge();


    }

    initBagItem(ndName:ESubView=ESubView.Bag){
        this.createBagItem(ndName); // 创建所有背包格子
        const bagItems = Core.Instance.bag.getItems();

        const contentNode = this.ndForge.getChildByName("ScrollView").getChildByName("view").getChildByName("content");
        
        // 遍历所有背包格子并初始化
        for (let i = 0; i < contentNode.children.length; i++) {
            const bagItemNode = contentNode.children[i];
            const bagItemComp = bagItemNode.getComponent(BagItem);
            
            if (i < bagItems.length) {
                // 初始化有物品的格子
                bagItemComp.init(bagItems[i]);
                bagItemNode.active = true;
            } else {
                // 保持空格子显示（但无物品）
                //bagItemComp.init(null); // 初始化为空状态
            }
        }

    }


    unloadCurrentItem() {
        console.log("卸载当前装备信息 unloadCurrentEquipment");
        // 清除当前装备信息
        this.ndForgeBagItem.destroy()
        //this.lbDesc_current.string = ""; // 清除描述
        //this.lbName_current.string = ""; // 清除名称
        //this.lbProfession_current.string = ""; // 清除职业限制
        this.lbAPDP_forge.string = ""; // 清除APDP

        this.ndAffixParent.children.forEach(node => node.active = false); // 隐藏所有词缀节点

        //this.ndWuxingAffixParent_current.children.forEach(node => node.active = false); // 隐藏所有五行词缀节点
    }

    onButtonLoadItemToForge(){
        if (!Core.Instance.currentItem) return;
        // this.unloadCurrentItem(); // 清除之前的装备信息
        // console.log("锻造装备onButtonLoadItemToForge加载装备信息,选择的装备格子:", value);
        // console.log("锻造装备onButtonLoadItemToForge currentITem", Core.Instance.currentItem);
        // this.value_forge = value;
        this.unloadCurrentItem(); // 清除之前的装备信息
        // this.forgeItems=Core.Instance.bag.getEquipmentItems()

        // let num = Util.extractNumberFromEnd(value)-1
        // console.log("加载装备信息,选择的装备格子num:", num);
        // this.equipment_forge = this.forgeItems[num] as Equipment;
        // console.log("加载新装备信息,新装备:", this.equipment_forge);
        // if (!this.equipment_forge) {return}


        this.equipment_forge = Core.Instance.currentItem as Equipment;

        const prefab = ResourceManager.Instance.getResourceCache().get(PrefabPath.BagItem) as Prefab;
        const bagItemNode = instantiate(prefab);
        bagItemNode.setParent(this.ndForge.getChildByName("Board").getChildByName("Icon"));
        bagItemNode.setPosition(0,0);
        bagItemNode.getComponent(BagItem).init(this.equipment_forge);


        // 显示物品描述
        // this.lbDesc_new.string = this.newEquipment.desc || "无描述";
        // this.lbName_new.string = this.newEquipment.name || "无名称";
        // this.lbProfession_new.string = this.showProfessionRestrictions(this.newEquipment)

        // 显示APDP
        if(this.equipment_forge.ap === 0){
            this.lbAPDP_forge.string = `防御力: ${this.equipment_forge.dp}`;
        }else{
            this.lbAPDP_forge.string = `攻击力: ${this.equipment_forge.ap}`;
        }

        // 显示词缀
        if (this.equipment_forge.itemType === EItemType.Equipment || this.equipment_forge.itemType === EItemType.Gem) {
            this.showAffixes(this.equipment_forge, this.ndAffixParent);
            //this.showWuxingAffixes(this.newEquipment, this.ndWuxingAffixParent_new);
        }



        //this.ndButton.active = true; // 显示按钮
        


    }

    private showAffixes(equipment: IEquipment, affixParent): void {
        // 隐藏所有词缀节点
        affixParent.children.forEach(node => node.active = false);
        
        // 显示当前装备的词缀
        if (equipment.affixes && equipment.affixes.length > 0) {
            for (let i = 0; i < equipment.affixes.length; i++) {
                const affixNode = affixParent.children[i];
                if (affixNode) {
                    affixNode.getComponent(Label).string = equipment.affixes[i].description;
                    affixNode.active = true;
                }
            }
        }
    }

    
    onButtonStrengthen(){
        console.log("强化")
        // 获取当前装备
        console.log("当前锻造装备:", this.equipment_forge);
        const equipment = this.equipment_forge;
        if (!equipment) {
            console.log("没有选择装备");
            return;
        }
        // 检查是否可以强化
        // 检查等级
        if (equipment.level >= MAX_QUIPMENT_LEVEL) {
            Core.Instance.showTips("装备已达最高等级，无法强化！");
            return;
            
        }
        // 检查cost
        if (equipment.getStrengthenCost() > Core.Instance.gold) {
            Core.Instance.showTips("铜钱不足，无法强化！");
            return;
            
        }
        // 可以强化
        let result = equipment.strengthen();
        if (result) {
            Core.Instance.showTips("装备强化成功！");
            // 更新显示
            this.initBagItem(ESubView.Forge);
            this.onButtonLoadItemToForge();
        }
    }



}